'use strict';

import { ModelStatus } from './types'

export default app => {
  const mongoose = app.mongoose;
  const Schema = mongoose.Schema;

  const dataSchema = new Schema({

    /**
     * 创建时间
     */
    createTime: { type: Date, default: new Date() },
    /**
     * 数据(只能是字符串)
     */
    data: { type: String, default: '' },
    /**
     * 数组排序方式，用于数据排序
     */
    index: { type: Number, default: 0 },
    /**
     * 创建人
     */
    createUser: { type: Schema.Types.ObjectId, ref: 'User' },
    /**
     * 父类数据的ID（这里不能指定类因为，父类可能是Enum 或者 Data）
     */
    superId: { type: Schema.Types.ObjectId, index: true },
    /**
     * 用于记录在那个 enum 上，便于删除enum的时候删除数据
     */
    enumId: { type: Schema.Types.ObjectId, ref: 'Enum' },
    /**
     * 状态，是否删除
     */
    status: { type: Number, enum: [ ModelStatus.NORMAL, ModelStatus.DELETE ], default: ModelStatus.NORMAL },
    /**
     * 对应的项目ID，因为需要权限校验，只有符合的权限项目才能修改
     */
    project: { type: Schema.Types.ObjectId, ref: 'Project' },
  });

  /**
   * 查询单个数据
   */
  dataSchema.statics.findWithId = async function(id) {
    return this.findOne({
      _id: mongoose.Types.ObjectId(id),
    });
  };

  /**
   * 查询数据的记录
   */
  dataSchema.statics.findRecordWithId = async function(superId, { pageSize, pageNum, startTime, endTime }) {
 
    const skip = (pageNum - 1) * pageSize;
    const params: any = {
      superId,
    }
    if (startTime && endTime) {
      params.createTime = {
        $gte: parseInt(startTime),
        $lte: parseInt(endTime),
      }
    }
    return this
    .find(params)
    .populate({
      path: 'createUser',
      select: 'name'
    })
    .skip(skip)
    .limit(pageSize)
    .sort({ createTime: -1 })
    .exec();
  };

  /**
   * 查询 dataArr 的数组
   */
  dataSchema.statics.findDataArrWithSuperId = async function(superId, { pageSize, pageNum, startTime, endTime, indexSort, status = '0' }) {
 
    const skip = (pageNum - 1) * pageSize;
    const params: any = {
      superId: mongoose.Types.ObjectId(superId),
      status: parseInt(status)
    }
    if (startTime && endTime) {
      params.createTime = {
        $gte: parseInt(startTime),
        $lte: parseInt(endTime),
      }
    }
    return this
    .find(params)
    .populate({
      path: 'createUser',
      select: 'name'
    })
    .skip(skip)
    .limit(pageSize)
    .sort({ index: parseInt(indexSort) })
    .exec();
  };

  /**
   * 查询 dataArr 的数组（获取数据的时候抵用）
   */
  dataSchema.statics.getDataArrWithSuperId = async function(superId, { pageSize, pageNum, startTime, endTime, indexSort }) {
 
    const skip = (pageNum - 1) * pageSize;
    const params: any = {
      superId: mongoose.Types.ObjectId(superId),
      status: ModelStatus.NORMAL
    }
    if (startTime && endTime) {
      params.createTime = {
        $gte: parseInt(startTime),
        $lte: parseInt(endTime),
      }
    }
    return this
    .find(params, 'createTime data index')
    .skip(skip)
    .limit(pageSize)
    .sort({ index: parseInt(indexSort) })
    .exec();
  };

  /**
   * 查询数组数据的个数
   */
  dataSchema.statics.findDataArrCountWithSuperId = async function(superId, { startTime, endTime, status = '0' }) {
    const params: any = {
      superId: mongoose.Types.ObjectId(superId),
      status: parseInt(status)
    }
    if (startTime && endTime) {
      params.createTime = {
        $gte: parseInt(startTime),
        $lte: parseInt(endTime),
      }
    }
    return this.countDocuments(params);
  };

  /**
   * 查询数据的记录个数
   */
  dataSchema.statics.findRecordCountWithId = async function(superId) {
    return this.countDocuments({
      superId
    });
  };

  /**
   * 删除当前记录
   */
  dataSchema.statics.removeWithId = async function(id) {
    return this.deleteOne({
      _id: mongoose.Types.ObjectId(id),
    });
  };

  /**
   * 更新数据
   */
  dataSchema.statics.updateWithId = function(id, upData) {
    return this.updateOne({ 
      _id: mongoose.Types.ObjectId(id), 
    }, upData);
  };

  /**
   * 批量删除数据
   */
  dataSchema.statics.removeAllEnumData = function(enumId) {
    return this.deleteMany({
      enumId: mongoose.Types.ObjectId(enumId), 
    });
  };

  return mongoose.model('Data', dataSchema, 'datas');
};